// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/disk_cache/blockfile/file.h"

#include <limits.h>
#include <stdint.h>

#include <limits>
#include <utility>

#include "base/bind.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/threading/worker_pool.h"
#include "net/base/net_errors.h"
#include "net/disk_cache/blockfile/in_flight_io.h"
#include "net/disk_cache/disk_cache.h"

namespace {

// This class represents a single asynchronous IO operation while it is being
// bounced between threads.
class FileBackgroundIO : public disk_cache::BackgroundIO {
public:
    // Other than the actual parameters for the IO operation (including the
    // |callback| that must be notified at the end), we need the controller that
    // is keeping track of all operations. When done, we notify the controller
    // (we do NOT invoke the callback), in the worker thead that completed the
    // operation.
    FileBackgroundIO(disk_cache::File* file, const void* buf, size_t buf_len,
        size_t offset, disk_cache::FileIOCallback* callback,
        disk_cache::InFlightIO* controller)
        : disk_cache::BackgroundIO(controller)
        , callback_(callback)
        , file_(file)
        , buf_(buf)
        , buf_len_(buf_len)
        , offset_(offset)
    {
    }

    disk_cache::FileIOCallback* callback()
    {
        return callback_;
    }

    disk_cache::File* file()
    {
        return file_;
    }

    // Read and Write are the operations that can be performed asynchronously.
    // The actual parameters for the operation are setup in the constructor of
    // the object. Both methods should be called from a worker thread, by posting
    // a task to the WorkerPool (they are RunnableMethods). When finished,
    // controller->OnIOComplete() is called.
    void Read();
    void Write();

private:
    ~FileBackgroundIO() override { }

    disk_cache::FileIOCallback* callback_;

    disk_cache::File* file_;
    const void* buf_;
    size_t buf_len_;
    size_t offset_;

    DISALLOW_COPY_AND_ASSIGN(FileBackgroundIO);
};

// The specialized controller that keeps track of current operations.
class FileInFlightIO : public disk_cache::InFlightIO {
public:
    FileInFlightIO() { }
    ~FileInFlightIO() override { }

    // These methods start an asynchronous operation. The arguments have the same
    // semantics of the File asynchronous operations, with the exception that the
    // operation never finishes synchronously.
    void PostRead(disk_cache::File* file, void* buf, size_t buf_len,
        size_t offset, disk_cache::FileIOCallback* callback);
    void PostWrite(disk_cache::File* file, const void* buf, size_t buf_len,
        size_t offset, disk_cache::FileIOCallback* callback);

protected:
    // Invokes the users' completion callback at the end of the IO operation.
    // |cancel| is true if the actual task posted to the thread is still
    // queued (because we are inside WaitForPendingIO), and false if said task is
    // the one performing the call.
    void OnOperationComplete(disk_cache::BackgroundIO* operation,
        bool cancel) override;

private:
    DISALLOW_COPY_AND_ASSIGN(FileInFlightIO);
};

// ---------------------------------------------------------------------------

// Runs on a worker thread.
void FileBackgroundIO::Read()
{
    if (file_->Read(const_cast<void*>(buf_), buf_len_, offset_)) {
        result_ = static_cast<int>(buf_len_);
    } else {
        result_ = net::ERR_CACHE_READ_FAILURE;
    }
    NotifyController();
}

// Runs on a worker thread.
void FileBackgroundIO::Write()
{
    bool rv = file_->Write(buf_, buf_len_, offset_);

    result_ = rv ? static_cast<int>(buf_len_) : net::ERR_CACHE_WRITE_FAILURE;
    NotifyController();
}

// ---------------------------------------------------------------------------

void FileInFlightIO::PostRead(disk_cache::File* file, void* buf, size_t buf_len,
    size_t offset, disk_cache::FileIOCallback* callback)
{
    scoped_refptr<FileBackgroundIO> operation(
        new FileBackgroundIO(file, buf, buf_len, offset, callback, this));
    file->AddRef(); // Balanced on OnOperationComplete()

    base::WorkerPool::PostTask(FROM_HERE,
        base::Bind(&FileBackgroundIO::Read, operation.get()), true);
    OnOperationPosted(operation.get());
}

void FileInFlightIO::PostWrite(disk_cache::File* file, const void* buf,
    size_t buf_len, size_t offset,
    disk_cache::FileIOCallback* callback)
{
    scoped_refptr<FileBackgroundIO> operation(
        new FileBackgroundIO(file, buf, buf_len, offset, callback, this));
    file->AddRef(); // Balanced on OnOperationComplete()

    base::WorkerPool::PostTask(FROM_HERE,
        base::Bind(&FileBackgroundIO::Write, operation.get()), true);
    OnOperationPosted(operation.get());
}

// Runs on the IO thread.
void FileInFlightIO::OnOperationComplete(disk_cache::BackgroundIO* operation,
    bool cancel)
{
    FileBackgroundIO* op = static_cast<FileBackgroundIO*>(operation);

    disk_cache::FileIOCallback* callback = op->callback();
    int bytes = operation->result();

    // Release the references acquired in PostRead / PostWrite.
    op->file()->Release();
    callback->OnFileIOComplete(bytes);
}

// A static object that will broker all async operations.
FileInFlightIO* s_file_operations = NULL;

// Returns the current FileInFlightIO.
FileInFlightIO* GetFileInFlightIO()
{
    if (!s_file_operations) {
        s_file_operations = new FileInFlightIO;
    }
    return s_file_operations;
}

// Deletes the current FileInFlightIO.
void DeleteFileInFlightIO()
{
    DCHECK(s_file_operations);
    delete s_file_operations;
    s_file_operations = NULL;
}

} // namespace

namespace disk_cache {

File::File(base::File file)
    : init_(true)
    , mixed_(true)
    , base_file_(std::move(file))
{
}

bool File::Init(const base::FilePath& name)
{
    if (base_file_.IsValid())
        return false;

    int flags = base::File::FLAG_OPEN | base::File::FLAG_READ | base::File::FLAG_WRITE;
    base_file_.Initialize(name, flags);
    return base_file_.IsValid();
}

bool File::IsValid() const
{
    return base_file_.IsValid();
}

bool File::Read(void* buffer, size_t buffer_len, size_t offset)
{
    DCHECK(base_file_.IsValid());
    if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) || offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
        return false;
    }

    int ret = base_file_.Read(offset, static_cast<char*>(buffer), buffer_len);
    return (static_cast<size_t>(ret) == buffer_len);
}

bool File::Write(const void* buffer, size_t buffer_len, size_t offset)
{
    DCHECK(base_file_.IsValid());
    if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) || offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
        return false;
    }

    int ret = base_file_.Write(offset, static_cast<const char*>(buffer),
        buffer_len);
    return (static_cast<size_t>(ret) == buffer_len);
}

// We have to increase the ref counter of the file before performing the IO to
// prevent the completion to happen with an invalid handle (if the file is
// closed while the IO is in flight).
bool File::Read(void* buffer, size_t buffer_len, size_t offset,
    FileIOCallback* callback, bool* completed)
{
    DCHECK(base_file_.IsValid());
    if (!callback) {
        if (completed)
            *completed = true;
        return Read(buffer, buffer_len, offset);
    }

    if (buffer_len > ULONG_MAX || offset > ULONG_MAX)
        return false;

    GetFileInFlightIO()->PostRead(this, buffer, buffer_len, offset, callback);

    *completed = false;
    return true;
}

bool File::Write(const void* buffer, size_t buffer_len, size_t offset,
    FileIOCallback* callback, bool* completed)
{
    DCHECK(base_file_.IsValid());
    if (!callback) {
        if (completed)
            *completed = true;
        return Write(buffer, buffer_len, offset);
    }

    return AsyncWrite(buffer, buffer_len, offset, callback, completed);
}

bool File::SetLength(size_t length)
{
    DCHECK(base_file_.IsValid());
    if (length > std::numeric_limits<uint32_t>::max())
        return false;

    return base_file_.SetLength(length);
}

size_t File::GetLength()
{
    DCHECK(base_file_.IsValid());
    int64_t len = base_file_.GetLength();

    if (len > static_cast<int64_t>(std::numeric_limits<uint32_t>::max()))
        return std::numeric_limits<uint32_t>::max();

    return static_cast<size_t>(len);
}

// Static.
void File::WaitForPendingIO(int* num_pending_io)
{
    // We may be running unit tests so we should allow be able to reset the
    // message loop.
    GetFileInFlightIO()->WaitForPendingIO();
    DeleteFileInFlightIO();
}

// Static.
void File::DropPendingIO()
{
    GetFileInFlightIO()->DropPendingIO();
    DeleteFileInFlightIO();
}

File::~File()
{
}

base::PlatformFile File::platform_file() const
{
    return base_file_.GetPlatformFile();
}

bool File::AsyncWrite(const void* buffer, size_t buffer_len, size_t offset,
    FileIOCallback* callback, bool* completed)
{
    DCHECK(base_file_.IsValid());
    if (buffer_len > ULONG_MAX || offset > ULONG_MAX)
        return false;

    GetFileInFlightIO()->PostWrite(this, buffer, buffer_len, offset, callback);

    if (completed)
        *completed = false;
    return true;
}

} // namespace disk_cache
